// controllers/workflowController.js
const Workflow = require('../models/Workflow');

class WorkflowController {
  // 创建新工作流
  static async createWorkflow(req, res) {
    try {
      const { name, description, nodes, edges } = req.body;
      const created_by = req.user.id; // 假设有用户认证
      
      const workflowId = await Workflow.create({
        name,
        description,
        nodes_data: nodes,
        edges_data: edges,
        created_by
      });
      
      res.status(201).json({
        success: true,
        message: '工作流创建成功',
        data: { id: workflowId }
      });
    } catch (error) {
      console.error('创建工作流失败:', error);
      res.status(500).json({
        success: false,
        message: '创建工作流失败',
        error: error.message
      });
    }
  }
  
  // 获取工作流详情
  static async getWorkflow(req, res) {
    try {
      const { id } = req.params;
      const workflow = await Workflow.findById(id);
      
      if (!workflow) {
        return res.status(404).json({
          success: false,
          message: '工作流不存在'
        });
      }
      
      res.json({
        success: true,
        data: workflow
      });
    } catch (error) {
      console.error('获取工作流失败:', error);
      res.status(500).json({
        success: false,
        message: '获取工作流失败',
        error: error.message
      });
    }
  }
  
  // 获取用户的工作流列表
  static async getUserWorkflows(req, res) {
    try {
      const userId = req.user.id;
      const workflows = await Workflow.findByUser(userId);
      
      res.json({
        success: true,
        data: workflows
      });
    } catch (error) {
      console.error('获取工作流列表失败:', error);
      res.status(500).json({
        success: false,
        message: '获取工作流列表失败',
        error: error.message
      });
    }
  }
  
  // 更新工作流
  static async updateWorkflow(req, res) {
    try {
      const { id } = req.params;
      const { name, description, nodes, edges } = req.body;
      
      const updated = await Workflow.update(id, {
        name,
        description,
        nodes_data: nodes,
        edges_data: edges
      });
      
      if (!updated) {
        return res.status(404).json({
          success: false,
          message: '工作流不存在'
        });
      }
      
      res.json({
        success: true,
        message: '工作流更新成功'
      });
    } catch (error) {
      console.error('更新工作流失败:', error);
      res.status(500).json({
        success: false,
        message: '更新工作流失败',
        error: error.message
      });
    }
  }
  
  // 删除工作流
  static async deleteWorkflow(req, res) {
    try {
      const { id } = req.params;
      const deleted = await Workflow.delete(id);
      
      if (!deleted) {
        return res.status(404).json({
          success: false,
          message: '工作流不存在'
        });
      }
      
      res.json({
        success: true,
        message: '工作流删除成功'
      });
    } catch (error) {
      console.error('删除工作流失败:', error);
      res.status(500).json({
        success: false,
        message: '删除工作流失败',
        error: error.message
      });
    }
  }
  
  // 执行工作流
  static async executeWorkflow(req, res) {
    try {
      const { id } = req.params;
      const { input_data } = req.body;
      const created_by = req.user.id;
      
      // 先验证工作流存在
      const workflow = await Workflow.findById(id);
      if (!workflow) {
        return res.status(404).json({
          success: false,
          message: '工作流不存在'
        });
      }
      
      // 创建执行记录
      const executionId = await Workflow.saveExecution({
        workflow_id: id,
        status: 'running',
        input_data: input_data || {},
        created_by
      });
      
      // 这里可以触发工作流执行引擎
      // 为了示例，我们模拟异步执行
      setTimeout(async () => {
        try {
          // 模拟执行结果
          const outputData = {
            execution_time: '2.5s',
            result: 'success',
            processed_data: input_data
          };
          
          await Workflow.updateExecutionStatus(executionId, 'completed', outputData);
          console.log(`工作流 ${id} 执行完成`);
        } catch (error) {
          console.error('工作流执行失败:', error);
          await Workflow.updateExecutionStatus(executionId, 'failed');
        }
      }, 2000);
      
      res.json({
        success: true,
        message: '工作流开始执行',
        data: { executionId }
      });
    } catch (error) {
      console.error('执行工作流失败:', error);
      res.status(500).json({
        success: false,
        message: '执行工作流失败',
        error: error.message
      });
    }
  }
  
  // 获取执行历史
  static async getExecutionHistory(req, res) {
    try {
      const { id } = req.params;
      const executions = await Workflow.getExecutions(id);
      
      res.json({
        success: true,
        data: executions
      });
    } catch (error) {
      console.error('获取执行历史失败:', error);
      res.status(500).json({
        success: false,
        message: '获取执行历史失败',
        error: error.message
      });
    }
  }
}

module.exports = WorkflowController;